जावास्क्रिप्ट जेनरेटर फंक्शन कंपोजिशन: जेनरेटर चेन बनाना

जावास्क्रिप्ट जेनरेटर फ़ंक्शंस इटरेबल सीक्वेंस बनाने का एक शक्तिशाली तरीका प्रदान करते हैं। वे एक्सेक्यूशन को रोकते हैं और मान यील्ड (yield) करते हैं, जिससे कुशल और लचीली डेटा प्रोसेसिंग की अनुमति मिलती है। जेनरेटर की सबसे दिलचस्प क्षमताओं में से एक उनकी एक साथ कंपोज़ होने की क्षमता है, जिससे परिष्कृत डेटा पाइपलाइन बनती हैं। यह पोस्ट जेनरेटर फ़ंक्शन कंपोजिशन की अवधारणा पर गहराई से विचार करेगी, जिसमें जटिल समस्याओं को हल करने के लिए जेनरेटर चेन बनाने की विभिन्न तकनीकों की खोज की जाएगी।

जावास्क्रिप्ट जेनरेटर फ़ंक्शंस क्या हैं?

कंपोजिशन में गोता लगाने से पहले, आइए संक्षेप में जेनरेटर फ़ंक्शंस की समीक्षा करें। एक जेनरेटर फ़ंक्शन function* सिंटैक्स का उपयोग करके परिभाषित किया गया है। जेनरेटर फ़ंक्शन के अंदर, yield कीवर्ड का उपयोग एक्सेक्यूशन को रोकने और एक मान वापस करने के लिए किया जाता है। जब जेनरेटर का next() मेथड कॉल किया जाता है, तो एक्सेक्यूशन वहीं से फिर से शुरू होता है जहाँ से वह अगले yield स्टेटमेंट या फ़ंक्शन के अंत तक छोड़ा गया था।

यहाँ एक सरल उदाहरण है:

            
function* numberGenerator(max) {
  for (let i = 0; i <= max; i++) {
    yield i;
  }
}

const generator = numberGenerator(5);

console.log(generator.next()); // Output: { value: 0, done: false }
console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: false }
console.log(generator.next()); // Output: { value: 4, done: false }
console.log(generator.next()); // Output: { value: 5, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

यह जेनरेटर फ़ंक्शन 0 से एक निर्दिष्ट अधिकतम मान तक संख्याएँ यील्ड करता है। next() मेथड दो गुणों वाला एक ऑब्जेक्ट लौटाता है: value (यील्ड किया गया मान) और done (एक बूलियन जो इंगित करता है कि जेनरेटर समाप्त हो गया है या नहीं)।

जेनरेटर फ़ंक्शंस को कंपोज़ क्यों करें?

जेनरेटर फ़ंक्शंस को कंपोज़ करने से आप मॉड्यूलर और पुन: प्रयोज्य डेटा प्रोसेसिंग पाइपलाइन बना सकते हैं। एक एकल, मोनोलिथिक जेनरेटर लिखने के बजाय जो सभी प्रोसेसिंग स्टेप्स करता है, आप समस्या को छोटे, अधिक प्रबंधनीय जेनरेटर में तोड़ सकते हैं, प्रत्येक एक विशिष्ट कार्य के लिए जिम्मेदार है। इन जेनरेटर को फिर एक पूरी पाइपलाइन बनाने के लिए एक साथ जोड़ा जा सकता है।

कंपोजिशन के इन लाभों पर विचार करें:

• मॉड्यूलरिटी: प्रत्येक जेनरेटर की एक ही जिम्मेदारी होती है, जिससे कोड को समझना और बनाए रखना आसान हो जाता है।
• पुन: प्रयोज्यता: जेनरेटर को विभिन्न पाइपलाइनों में पुन: उपयोग किया जा सकता है, जिससे कोड दोहराव कम होता है।
• परीक्षण क्षमता: छोटे जेनरेटर को अलग से परीक्षण करना आसान होता है।
• लचीलापन: जेनरेटर को जोड़ने, हटाने या फिर से व्यवस्थित करके पाइपलाइनों को आसानी से संशोधित किया जा सकता है।

जेनरेटर फ़ंक्शंस को कंपोज़ करने की तकनीकें

जावास्क्रिप्ट में जेनरेटर फ़ंक्शंस को कंपोज़ करने की कई तकनीकें हैं। आइए कुछ सबसे सामान्य तरीकों का पता लगाएं।

1. जेनरेटर डेलीगेशन (yield*)

yield* कीवर्ड किसी अन्य इटरेबल ऑब्जेक्ट को डेलीगेट करने का एक सुविधाजनक तरीका प्रदान करता है, जिसमें दूसरा जेनरेटर फ़ंक्शन भी शामिल है। जब yield* का उपयोग किया जाता है, तो डेलीगेटेड इटरेबल द्वारा यील्ड किए गए मान सीधे वर्तमान जेनरेटर द्वारा यील्ड किए जाते हैं।

यहाँ दो जेनरेटर फ़ंक्शंस को कंपोज़ करने के लिए yield* का उपयोग करने का एक उदाहरण है:

            
function* generateEvenNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 === 0) {
      yield i;
    }
  }
}

function* prependMessage(message, iterable) {
  yield message;
  yield* iterable;
}

const evenNumbers = generateEvenNumbers(10);
const messageGenerator = prependMessage("Even Numbers:", evenNumbers);

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// Even Numbers:
// 0
// 2
// 4
// 6
// 8
// 10

            

              
                Copy
              
            
          

इस उदाहरण में, prependMessage एक संदेश यील्ड करता है और फिर yield* का उपयोग करके generateEvenNumbers जेनरेटर को डेलीगेट करता है। यह प्रभावी रूप से दो जेनरेटर को एक ही सीक्वेंस में जोड़ता है।

2. मैनुअल इटरेशन और यील्डिंग

आप डेलीगेटेड जेनरेटर पर इटरेट करके और उसके मानों को यील्ड करके भी जेनरेटर को मैन्युअल रूप से कंपोज़ कर सकते हैं। यह दृष्टिकोण कंपोजिशन प्रक्रिया पर अधिक नियंत्रण प्रदान करता है लेकिन अधिक कोड की आवश्यकता होती है।

            
function* generateOddNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 !== 0) {
      yield i;
    }
  }
}

function* appendMessage(iterable, message) {
  for (const value of iterable) {
    yield value;
  }
  yield message;
}

const oddNumbers = generateOddNumbers(9);
const messageGenerator = appendMessage(oddNumbers, "End of Sequence");

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// 1
// 3
// 5
// 7
// 9
// End of Sequence

            

              
                Copy
              
            
          

इस उदाहरण में, appendMessage एक for...of लूप का उपयोग करके oddNumbers जेनरेटर पर इटरेट करता है और प्रत्येक मान को यील्ड करता है। पूरे जेनरेटर पर इटरेट करने के बाद, यह अंतिम संदेश यील्ड करता है।

3. हायर-ऑर्डर फ़ंक्शंस के साथ फंक्शनल कंपोजिशन

आप जेनरेटर कंपोजिशन की अधिक फंक्शनल और डिक्लेरेटिव शैली बनाने के लिए हायर-ऑर्डर फ़ंक्शंस का उपयोग कर सकते हैं। इसमें ऐसे फ़ंक्शंस बनाना शामिल है जो जेनरेटर को इनपुट के रूप में लेते हैं और नए जेनरेटर लौटाते हैं जो डेटा स्ट्रीम पर ट्रांसफॉर्मेशन करते हैं।

            
function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

function mapGenerator(generator, transform) {
  return function*() {
    for (const value of generator) {
      yield transform(value);
    }
  };
}

function filterGenerator(generator, predicate) {
  return function*() {
    for (const value of generator) {
      if (predicate(value)) {
        yield value;
      }
    }
  };
}

const numbers = numberRange(1, 10);
const squaredNumbers = mapGenerator(numbers, x => x * x)();
const evenSquaredNumbers = filterGenerator(squaredNumbers, x => x % 2 === 0)();

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

इस उदाहरण में, mapGenerator और filterGenerator हायर-ऑर्डर फ़ंक्शंस हैं जो एक जेनरेटर और एक ट्रांसफॉर्मेशन या प्रेडिकेट फ़ंक्शन को इनपुट के रूप में लेते हैं। वे नए जेनरेटर फ़ंक्शंस लौटाते हैं जो मूल जेनरेटर द्वारा यील्ड किए गए मानों पर ट्रांसफॉर्मेशन या फ़िल्टर लागू करते हैं। यह आपको इन हायर-ऑर्डर फ़ंक्शंस को एक साथ जोड़कर जटिल पाइपलाइन बनाने की अनुमति देता है।

4. जेनरेटर पाइपलाइन लाइब्रेरीज़ (उदा., IxJS)

कई जावास्क्रिप्ट लाइब्रेरीज़ इटरेबल्स और जेनरेटर के साथ अधिक फंक्शनल और डिक्लेरेटिव तरीके से काम करने के लिए यूटिलिटीज़ प्रदान करती हैं। एक उदाहरण IxJS (जावास्क्रिप्ट के लिए इंटरैक्टिव एक्सटेंशन) है, जो इटरेबल्स को ट्रांसफॉर्म करने और संयोजित करने के लिए ऑपरेटरों का एक समृद्ध सेट प्रदान करता है।

ध्यान दें: बाहरी लाइब्रेरी का उपयोग करने से आपके प्रोजेक्ट में निर्भरताएँ जुड़ जाती हैं। लाभ बनाम लागत का मूल्यांकन करें।

            
// Example using IxJS (install: npm install ix)
const { from, map, filter } = require('ix/iterable');

function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

const numbers = from(numberRange(1, 10));
const squaredNumbers = map(numbers, x => x * x);
const evenSquaredNumbers = filter(squaredNumbers, x => x % 2 === 0);

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

यह उदाहरण पिछले उदाहरण के समान ट्रांसफॉर्मेशन करने के लिए IxJS का उपयोग करता है, लेकिन अधिक संक्षिप्त और डिक्लेरेटिव तरीके से। IxJS map और filter जैसे ऑपरेटर प्रदान करता है जो इटरेबल्स पर काम करते हैं, जिससे जटिल डेटा प्रोसेसिंग पाइपलाइन बनाना आसान हो जाता है।

जेनरेटर फंक्शन कंपोजिशन के वास्तविक-दुनिया के उदाहरण

जेनरेटर फंक्शन कंपोजिशन को विभिन्न वास्तविक-दुनिया के परिदृश्यों पर लागू किया जा सकता है। यहाँ कुछ उदाहरण दिए गए हैं:

1. डेटा ट्रांसफॉर्मेशन पाइपलाइन

कल्पना कीजिए कि आप एक CSV फ़ाइल से डेटा प्रोसेस कर रहे हैं। आप विभिन्न ट्रांसफॉर्मेशन करने के लिए जेनरेटर की एक पाइपलाइन बना सकते हैं, जैसे:

• CSV फ़ाइल को पढ़ना और प्रत्येक पंक्ति को एक ऑब्जेक्ट के रूप में यील्ड करना।
• कुछ मानदंडों के आधार पर पंक्तियों को फ़िल्टर करना (जैसे, केवल एक विशिष्ट देश कोड वाली पंक्तियाँ)।
• प्रत्येक पंक्ति में डेटा को बदलना (जैसे, तिथियों को एक विशिष्ट प्रारूप में बदलना, गणना करना)।
• ट्रांसफॉर्म किए गए डेटा को एक नई फ़ाइल या डेटाबेस में लिखना।

इनमें से प्रत्येक चरण को एक अलग जेनरेटर फ़ंक्शन के रूप में लागू किया जा सकता है, और फिर एक पूर्ण डेटा प्रोसेसिंग पाइपलाइन बनाने के लिए एक साथ कंपोज़ किया जा सकता है। उदाहरण के लिए, यदि डेटा स्रोत विश्व स्तर पर ग्राहक स्थानों का एक CSV है, तो आपके पास देश के अनुसार फ़िल्टरिंग (जैसे, "जापान", "ब्राजील", "जर्मनी") जैसे चरण हो सकते हैं और फिर एक ऐसा ट्रांसफॉर्मेशन लागू कर सकते हैं जो एक केंद्रीय कार्यालय से दूरियों की गणना करता है।

2. एसिंक्रोनस डेटा स्ट्रीम्स

जेनरेटर का उपयोग एसिंक्रोनस डेटा स्ट्रीम को प्रोसेस करने के लिए भी किया जा सकता है, जैसे कि वेब सॉकेट या एपीआई से डेटा। आप एक जेनरेटर बना सकते हैं जो स्ट्रीम से डेटा प्राप्त करता है और प्रत्येक आइटम को उपलब्ध होने पर यील्ड करता है। इस जेनरेटर को फिर डेटा पर ट्रांसफॉर्मेशन और फ़िल्टरिंग करने के लिए अन्य जेनरेटर के साथ कंपोज़ किया जा सकता है।

एक पेजिनेटेड एपीआई से उपयोगकर्ता प्रोफाइल प्राप्त करने पर विचार करें। एक जेनरेटर प्रत्येक पेज को प्राप्त कर सकता है, और उस पेज से उपयोगकर्ता प्रोफाइल को yield* कर सकता है। दूसरा जेनरेटर इन प्रोफाइल को पिछले महीने की गतिविधि के आधार पर फ़िल्टर कर सकता है।

3. कस्टम इटरेटर लागू करना

जेनरेटर फ़ंक्शंस जटिल डेटा संरचनाओं के लिए कस्टम इटरेटर लागू करने का एक संक्षिप्त तरीका प्रदान करते हैं। आप एक जेनरेटर बना सकते हैं जो डेटा संरचना को पार करता है और उसके तत्वों को एक विशिष्ट क्रम में यील्ड करता है। इस इटरेटर का उपयोग तब for...of लूप या अन्य इटरेबल संदर्भों में किया जा सकता है।

उदाहरण के लिए, आप एक जेनरेटर बना सकते हैं जो एक बाइनरी ट्री को एक विशिष्ट क्रम में पार करता है (जैसे, इन-ऑर्डर, प्री-ऑर्डर, पोस्ट-ऑर्डर) या एक स्प्रेडशीट की कोशिकाओं के माध्यम से पंक्ति दर पंक्ति इटरेट करता है।

जेनरेटर फंक्शन कंपोजिशन के लिए सर्वश्रेष्ठ अभ्यास

जेनरेटर फ़ंक्शंस को कंपोज़ करते समय ध्यान में रखने के लिए यहां कुछ सर्वोत्तम अभ्यास दिए गए हैं:

• जेनरेटर को छोटा और केंद्रित रखें: प्रत्येक जेनरेटर की एक एकल, अच्छी तरह से परिभाषित जिम्मेदारी होनी चाहिए। यह कोड को समझने, परीक्षण करने और बनाए रखने में आसान बनाता है।
• वर्णनात्मक नामों का उपयोग करें: अपने जेनरेटर को वर्णनात्मक नाम दें जो उनके उद्देश्य को स्पष्ट रूप से इंगित करते हैं।
• त्रुटियों को शालीनता से संभालें: पाइपलाइन के माध्यम से त्रुटियों को फैलने से रोकने के लिए प्रत्येक जेनरेटर के भीतर त्रुटि प्रबंधन लागू करें। अपने जेनरेटर के भीतर try...catch ब्लॉक का उपयोग करने पर विचार करें।
• प्रदर्शन पर विचार करें: जबकि जेनरेटर आम तौर पर कुशल होते हैं, जटिल पाइपलाइन अभी भी प्रदर्शन को प्रभावित कर सकती हैं। अपने कोड को प्रोफाइल करें और जहां आवश्यक हो वहां ऑप्टिमाइज़ करें।
• अपने कोड का दस्तावेजीकरण करें: प्रत्येक जेनरेटर के उद्देश्य और यह पाइपलाइन में अन्य जेनरेटर के साथ कैसे इंटरैक्ट करता है, इसका स्पष्ट रूप से दस्तावेजीकरण करें।

उन्नत तकनीकें

जेनरेटर चेन में त्रुटि प्रबंधन

जेनरेटर चेन में त्रुटियों को संभालने के लिए सावधानीपूर्वक विचार करने की आवश्यकता है। जब किसी जेनरेटर के भीतर कोई त्रुटि होती है, तो यह पूरी पाइपलाइन को बाधित कर सकती है। कुछ रणनीतियाँ हैं जिन्हें आप अपना सकते हैं:

1. जेनरेटर के भीतर Try-Catch: सबसे सीधा तरीका यह है कि प्रत्येक जेनरेटर फ़ंक्शन के कोड को try...catch ब्लॉक में लपेटा जाए। यह आपको स्थानीय रूप से त्रुटियों को संभालने और संभावित रूप से एक डिफ़ॉल्ट मान या एक विशिष्ट त्रुटि ऑब्जेक्ट यील्ड करने की अनुमति देता है।
2. त्रुटि सीमाएँ (रिएक्ट से अवधारणा, यहाँ अनुकूलनीय): एक रैपर जेनरेटर बनाएं जो उसके डेलीगेटेड जेनरेटर द्वारा फेंके गए किसी भी अपवाद को पकड़ता है। यह आपको त्रुटि को लॉग करने और संभावित रूप से एक फॉलबैक मान के साथ चेन को फिर से शुरू करने की अनुमति देता है।

            
function* potentiallyFailingGenerator() {
  try {
    // Code that might throw an error
    const result = someRiskyOperation();
    yield result;
  } catch (error) {
    console.error("Error in potentiallyFailingGenerator:", error);
    yield null; // Or yield a specific error object
  }
}

function* errorBoundary(generator) {
    try {
        yield* generator();
    } catch (error) {
        console.error("Error Boundary Caught:", error);
        yield "Fallback Value"; // Or some other recovery mechanism
    }
}

const myGenerator = errorBoundary(potentiallyFailingGenerator);

for (const value of myGenerator) {
  console.log(value);
}

            

              
                Copy
              
            
          

एसिंक्रोनस जेनरेटर और कंपोजिशन

जावास्क्रिप्ट में एसिंक्रोनस जेनरेटर की शुरुआत के साथ, अब आप जेनरेटर चेन बना सकते हैं जो एसिंक्रोनस डेटा को अधिक स्वाभाविक रूप से प्रोसेस करती हैं। एसिंक्रोनस जेनरेटर async function* सिंटैक्स का उपयोग करते हैं और एसिंक्रोनस ऑपरेशंस की प्रतीक्षा करने के लिए await कीवर्ड का उपयोग कर सकते हैं।

            
async function* fetchUsers(userIds) {
  for (const userId of userIds) {
    const user = await fetchUser(userId); // Assuming fetchUser is an async function
    yield user;
  }
}

async function* filterActiveUsers(users) {
  for await (const user of users) {
    if (user.isActive) {
      yield user;
    }
  }
}

async function fetchUser(id) {
    //Simulate an async fetch
    return new Promise(resolve => {
        setTimeout(() => {
            resolve({ id: id, name: `User ${id}`, isActive: id % 2 === 0});
        }, 500);
    });
}

async function main() {
  const userIds = [1, 2, 3, 4, 5];
  const users = fetchUsers(userIds);
  const activeUsers = filterActiveUsers(users);

  for await (const user of activeUsers) {
    console.log(user);
  }
}

main();

//Possible output:
// { id: 2, name: 'User 2', isActive: true }
// { id: 4, name: 'User 4', isActive: true }

            

              
                Copy
              
            
          

एसिंक्रोनस जेनरेटर पर इटरेट करने के लिए, आपको for await...of लूप का उपयोग करने की आवश्यकता है। एसिंक्रोनस जेनरेटर को नियमित जेनरेटर की तरह ही yield* का उपयोग करके कंपोज़ किया जा सकता है।

निष्कर्ष

जेनरेटर फ़ंक्शन कंपोजिशन जावास्क्रिप्ट में मॉड्यूलर, पुन: प्रयोज्य और परीक्षण योग्य डेटा प्रोसेसिंग पाइपलाइन बनाने के लिए एक शक्तिशाली तकनीक है। जटिल समस्याओं को छोटे, प्रबंधनीय जेनरेटर में तोड़कर, आप अधिक रखरखाव योग्य और लचीला कोड बना सकते हैं। चाहे आप CSV फ़ाइल से डेटा ट्रांसफॉर्म कर रहे हों, एसिंक्रोनस डेटा स्ट्रीम प्रोसेस कर रहे हों, या कस्टम इटरेटर लागू कर रहे हों, जेनरेटर फ़ंक्शन कंपोजिशन आपको क्लीनर और अधिक कुशल कोड लिखने में मदद कर सकता है। जेनरेटर फ़ंक्शंस को कंपोज़ करने के लिए विभिन्न तकनीकों को समझकर, जिसमें जेनरेटर डेलीगेशन, मैनुअल इटरेशन, और हायर-ऑर्डर फ़ंक्शंस के साथ फंक्शनल कंपोजिशन शामिल है, आप अपने जावास्क्रिप्ट प्रोजेक्ट्स में जेनरेटर की पूरी क्षमता का लाभ उठा सकते हैं। सर्वोत्तम प्रथाओं का पालन करना याद रखें, त्रुटियों को शालीनता से संभालें, और अपने जेनरेटर पाइपलाइनों को डिजाइन करते समय प्रदर्शन पर विचार करें। विभिन्न दृष्टिकोणों के साथ प्रयोग करें और उन तकनीकों को खोजें जो आपकी आवश्यकताओं और कोडिंग शैली के लिए सबसे उपयुक्त हों। अंत में, अपने जेनरेटर-आधारित वर्कफ़्लो को और बढ़ाने के लिए IxJS जैसी मौजूदा लाइब्रेरी का अन्वेषण करें। अभ्यास के साथ, आप जावास्क्रिप्ट जेनरेटर फ़ंक्शंस का उपयोग करके परिष्कृत और कुशल डेटा प्रोसेसिंग समाधान बनाने में सक्षम होंगे।